Applications du RDF

Le RDF se retrouve un peu partout sur le web, parfois de façon « invisible », c'est-à-dire qu'il est souvent utilisé dans les échanges automatiques entre les logiciels. En outre, il est utilisé au sein des portails, par exemple. Voyons maintenant quatre applications RDF bien établies :

Dublin Core: Il s'agit sans doute de l'utilisation la plus connue et la plus répandue du RDF. La norme Dublin Core est assez simple et vise à décrire les travaux rendus disponibles sur le web (auteur, titre, date, etc.). Elle est notamment utilisée au sein des livres électroniques (comme les EPUB). Cette norme s'inspire de la bibliothéconomie.
Creative Commons: Il s'agit d'une façon de décrire les droits accordés sur le contenu placé sur le web. Par exemple, vous voulez savoir si vous pouvez recopier telle ou telle page web; si l'auteur a utilisé la norme Creative Commons, alors vous devriez pouvoir savoir ce qui est permis par l'auteur.
FOAF: La norme FOAF (« Friend Of A Friend » - « ami d'un ami ») permet de décrire un individu et les gens qu'il connaît. Cette norme sert à traiter les réseaux sociaux.
RSS/RDF: La norme RSS est utilisée par les blogues et sites de nouvelles. Le site mozilla.org a plusieurs articles sur le sujet (http://developer.mozilla.org/en/docs/RSS). En gros, un document RSS/RDF contient une version XML des dernières nouvelles. Par la suite, plusieurs de ces fichiers XML peuvent être combinés pour créer un portail de nouvelles ou utilisés avec un outil-client de type « RSS aggregator » pour obtenir automatiquement les dernières nouvelles.

Un exemple : Dublin Core

La norme Dublin Core définit plusieurs « verbes » (au sein du RDF); on peut en consulter la liste à l'adresse http://dublincore.org/documents/dcmi-terms/ (en anglais). Cette norme a été publiée pour la première fois en juillet 1999.

Le préfixe de la norme Dublin Core est « http://purl.org/dc/elements/1.1/ », du moins pour les éléments de base présentés ici. Voici les URI complets et leur signification :

http://purl.org/dc/elements/1.1/creator: Personne ou organisme qui est l'auteur du travail.
http://purl.org/dc/elements/1.1/contributor: Personne ou organisme qui a contribué à un travail, mais sans en être l'auteur.
http://purl.org/dc/elements/1.1/coverage: Lieu et période correspondant au travail.
http://purl.org/dc/elements/1.1/date: Date associée au travail, généralement sous la forme AAAA-MM-JJ. Il peut s'agir de la date de publication, de création ou de la dernière révision.
http://purl.org/dc/elements/1.1/description: Brève description du travail.
http://purl.org/dc/elements/1.1/format: Format sous lequel est publié le travail. Si le travail est publié en HTML, alors on utilisera souvent « text/html » pour décrire le format.
http://purl.org/dc/elements/1.1/identifier: Code ou URI qui correspond de façon unique au travail. Si un travail est publié à une adresse web, on peut utiliser cette adresse comme URI; si c'est un livre avec un ISBN, on peut utiliser un URI de la forme « urn:ISBN:0-123-12345-1 ».
http://purl.org/dc/elements/1.1/language: Code ISO-639/ISO-3166 décrivant le travail. Si le travail est publié en français, on peut utiliser « fr-CA »; sinon, en anglais, ce serait « en-CA » (CA signifie Canada).
http://purl.org/dc/elements/1.1/publisher: Organisme responsable de la publication du travail.
http://purl.org/dc/elements/1.1/relation: Ressource liée au travail. Par exemple, pour un travail fait en classe, on peut établir un lien avec l'exposé du travail.
http://purl.org/dc/elements/1.1/rights: Contient souvent une affirmation permettant de savoir qui est propriétaire du travail (détenteur du droit d'auteur).
http://purl.org/dc/elements/1.1/source: Résumé du travail de quelqu'un d'autre. Cet URI permet de pointer vers la source originale.
http://purl.org/dc/elements/1.1/subject: Généralement, une liste de mots clés.
http://purl.org/dc/elements/1.1/title: Titre du travail.
http://purl.org/dc/elements/1.1/type: Type de la ressource (texte, image, etc.). Notons que le « type » est différent du « format ». Par exemple, une image peut être en format Jpeg ou Gif, un texte peut être en format Word ou ASCII.

Voyons comment nous pouvons décrire ce texte que vous êtes en train de lire, en utilisant la norme Dublin Core. Attribuons-lui l'URI « http://teluq.ca/rdfexemples.html ».

Sujet	Verbe	Objet
http://teluq.ca/ rdfexemples.html	http://purl.org/ dc/elements/1.1/creator	http://lemire.me/fr/
http://teluq.ca/ rdfexemples.html	http://purl.org/ dc/elements/1.1/date	"2004-07-27"
http://teluq.ca/ rdfexemples.html	http://purl.org/ dc/elements/1.1/title	"Introduction au RDF"
http://teluq.ca/ rdfexemples.html	http://purl.org/ dc/elements/1.1/type	"text"
http://teluq.ca/ rdfexemples.html	http://purl.org/ dc/elements/1.1/Language	"fr-CA"
http://teluq.ca/ rdfexemples.html	http://purl.org/ dc/elements/1.1/subject	"RDF, Dublin Core, Creative Commons, FOAF, RSS/RDF"
http://teluq.ca/ rdfexemples.html	http://purl.org/ dc/elements/1.1/rights	"Copyright 2005 Daniel Lemire"
http://teluq.ca/ rdfexemples.html	http://purl.org/ dc/elements/1.1/description	"Un document comprenant des exemples d'utilisation du RDF en gestion des connaissances."
http://teluq.ca/ rdfexemples.html	http://purl.org/ dc/elements/1.1/format	"text/html"
http://teluq.ca/ rdfexemples.html	http://purl.org/ dc/elements/1.1/identifier	http://teluq.ca/ rdfexemples.html

Nous pouvons aussi représenter ce tableau en XML comme ceci :

<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
 xmlns:dc="http://purl.org/dc/elements/1.1/">
   <rdf:Description rdf:about="http://teluq.ca/rdfexemples.html">
     <dc:creator rdf:resource="http://lemire.me/fr/" />
     <dc:date>2004-07-27</dc:date>
     <dc:title>Introduction au RDF</dc:title>
     <dc:type>text</dc:type>
     <dc:Language>fr-CA</dc:Language>
     <dc:subject>RDF, Dublin Core, Creative Commons,
     FOAF, RSS/RDF</dc:subject>
     <dc:rights>Copyright 2005 Daniel Lemire</dc:rights>
     <dc:description>Un document comprenant des exemples
     d'utilisation du RDF en gestion des connaissances.</dc:description>
     <dc:format>text/html</dc:format>
     <dc:identifier 
     rdf:resource="http://teluq.ca/rdfexemples.html" />
  </rdf:Description>
 </rdf:RDF>

Nous pouvons aussi représenter ce tableau sous la forme d'un graphe :

Évidemment, Dublin Core est une norme RDF et non pas une norme XML. Il est donc possible d'exprimer du contenu Dublin Core sans passer par le XML. Nous pourrions très bien nous en tenir au tableau sujet/verbe/complément ou utiliser une autre syntaxe. Un syntaxe plus populaire que le XML est sans doute celle décrite par la RFC 2731. Elle est facile à comprendre: il suffit d'utiliser des éléments meta avec les attributs name et content. La convention est que si l'attribute débute par le préfixe « DC.» ce qui suit est une information Dublin Core. Voici un exemple:

<meta name    = "DC.date" 
 content = "2004-07-27" />
<meta name    = "DC.title" 
 content = "Introduction au RDF" />
<meta name    = "DC.type" 
 content = "text" />
<meta name    = "DC.Language" 
 content = "fr-CA" />
<meta name    = "DC.subject" 
 content = "RDF, Dublin Core, Creative Commons, FOAF, RSS/RDF" />
<meta name    = "DC.rights" 
 content = "Copyright 2005 Daniel Lemire" />
<meta name    = "DC.description" 
 content = "Un document comprenant des exemples
     d'utilisation du RDF en gestion des connaissances." />
<meta name    = "DC.format" 
 content = "text/html" />

Notons aussi que les conventions d'espace de noms s'appliquent et que l'ordre n'est pas important. Nous pouvons donc remplacer le XML précédent par celui-ci :

<?xml version="1.0" encoding="ISO-8859-1"?>
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
   xmlns="http://purl.org/dc/elements/1.1/">
   <rdf:Description rdf:about="http://teluq.ca/rdfexemples.html">
     <creator rdf:resource="http://lemire.me/fr/" />
     <title>Introduction au RDF</title>
     <date>2004-07-27</date>
     <type>text</type>     
     <subject>RDF, Dublin Core, Creative Commons,
     FOAF, RSS/RDF</subject>
     <rights>Copyright 2005 Daniel Lemire</rights>
     <description>Un document comprenant des exemples
     d'utilisation du RDF en gestion des connaissances.</description>
     <format>text/html</format>
     <identifier 
     rdf:resource="http://teluq.ca/rdfexemples.html" />
     <Language>fr-CA</Language>
  </rdf:Description>
</rdf:RDF>

Il existe des applications plus sophistiquées de la norme Dublin Core, mais nous avons ici l'essentiel. Vous pouvez dès maintenant cataloguer les ressources d'une entreprise en utilisant simplement ce que nous venons de présenter. Comme la norme est utilisée partout dans le monde, il sera possible d'échanger ces descriptions ou d'utiliser des logiciels communs pour le traitement ou l'affichage des informations.

Un exemple : Creative Commons

Une des limites apparentes de la norme Dublin Core est son incapacité à spécifier de façon précise les droits accordés sur un travail. Le problème est particulièrement fréquent sur le web : a-t-on le droit d'utiliser telle ou telle image gratuitement, de la reproduire, de la modifier, et ainsi de suite.

Pour résoudre cette difficulté, les gens font appel à la norme Creative Commons, qui utilise le préfixe « http://web.resource.org/cc/ ». Cette norme définit une classe « Work » (travail, en anglais, ici au sens d'oœuvre), mais emprunte pratiquement tout le reste à Dublin Core qu'elle vient compléter. La norme Creative Commons a été proposée en 2001 par James Boyle, Michael Carroll, Lawrence Lessig, Hal Abelson, Eric Saltzman et Eric Eldred.

Voici un exemple très simple d'une description utilisant la norme Creative Commons :

Sujet	Verbe	Objet
http://teluq.ca/ rdfexemples.html	http://www.w3.org/1999/ 02/22-rdf-syntax-ns#type	http://web.resource.org/ cc/Work
http://teluq.ca/ rdfexemples.html	http://purl.org/ dc/elements/1.1/title	"Le RDF par l'exemple"

Et voici la version XML correspondante :

<?xml version="1.0" encoding="ISO-8859-1"?>
<rdf:RDF xmlns="http://web.resource.org/cc/"
  xmlns:dc="http://purl.org/dc/elements/1.1/"
  xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
 <Work rdf:about="http://teluq.ca/rdfexemples.html">
  <dc:title>Le RDF par l'exemple</dc:title>
</Work>
</rdf:RDF>

Tout ce que nous avons affirmé dans ce dernier document, c'est que la page actuelle appartient à la classe « Work ». Dans l'état actuel des choses, nous affirmons par défaut qu'il n'est pas permis d'utiliser cette page, car nous n'avons attribué aucune permission.

Supposons que l'auteur désire accorder le droit au lecteur de redistribuer, de modifier et de partager cette page, pour autant qu'il utilise la même licence. Nous pourrions alors utiliser la licence « Attribution-ShareAlike 2.0 » dont l'URI est « http://creativecommons.org/licenses/by-sa/2.0/ ». Évidemment, nous pouvons aussi créer notre licence de toute pièce, mais dans l'exemple, nous utiliserons la licence « Attribution-ShareAlike 2.0 ». Pour faire un lien entre notre travail et une licence, nous utilisons le verbe dont l'URI est « http://web.resource.org/cc/license », comme ce qui suit; observez bien la dernière ligne du tableau.

Sujet	Verbe	Objet
http://teluq.ca/ rdfexemples.html	http://www.w3.org/1999/ 02/22-rdf-syntax-ns#type	http://web.resource.org/ cc/Work
http://teluq.ca/ rdfexemples.html	http://purl.org/ dc/elements/1.1/title	"Le RDF par l'exemple"
http://teluq.ca/ rdfexemples.html	http://web.resource.org/ cc/license	http://creativecommons.org/licenses/by-sa/2.0/

Nous pouvons aussi utiliser le XML correspondant :

<?xml version="1.0" encoding="ISO-8859-1"?>
<rdf:RDF xmlns="http://web.resource.org/cc/"
  xmlns:dc="http://purl.org/dc/elements/1.1/"
  xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
  <Work rdf:about="http://teluq.ca/rdfexemples.html">
  <dc:title>Le RDF par l'exemple</dc:title>
  <license 
  rdf:resource="http://creativecommons.org/licenses/by-sa/2.0/" /> 
</Work>
</rdf:RDF>

Voici la représentation sous la forme d'un graphe :

Nous avons alors un document Creative Commons complet. Cependant, un problème demeure. Supposons qu'un logiciel fasse automatiquement une recherche pour vous et que vous ne désiriez obtenir que les textes que vous pouvez modifier librement. Il n'est pas évident pour une machine de comprendre que l'URI « http://creativecommons.org/licenses/by-sa/2.0/ » vous donne ce droit; d'ailleurs, une telle recherche n'est peut-être pas très simple pour un humain...

Creative Commons définit trois verbes et des objets permettant de décrire une licence et une classe. Toutes les licences appartiennent à la classe ayant pour URI « http://web.resource.org/cc/License ». Les URI des trois verbes sont :

http://web.resource.org/cc/permits: La licence le permet. Creative Commons définit trois URI pouvant être utilisés comme objet de ce verbe. Il y a d'abord « http://web.resource.org/cc/Reproduction », le droit de reproduire en tout ou en partie le travail. Il y a ensuite « http://web.resource.org/cc/Distribution », le droit de redistribuer le travail. Finalement, il y a « http://web.resource.org/cc/DerivativeWorks », le droit de modifier le travail. Évidemment, il est possible de définir ses propres objets.
http://web.resource.org/cc/requires: La licence pose comme condition. Creatives Commons définit quatre URI pouvant être utilisés comme objet de ce verbe : « http://web.resource.org/cc/Notice » pour spécifier qu'il faut reproduire intégralement les notes légales (licence et droits d'auteurs); « http://web.resource.org/cc/Attribution » pour spécifier qu'il faut attribuer à l'auteur le crédit du travail; « http://web.resource.org/cc/ShareAlike » pour spécifier que si l'on redistribue le travail, il faut le faire en gardant la même licence; « http://web.resource.org/cc/SourceCode » pour spécifier que le code source doit être redistribué.
http://web.resource.org/cc/prohibits: La licence interdit. Il n'y a qu'un seul URI défini par Creative Commons qui peut être utilisé avec ce verbe : « http://web.resource.org/cc/CommercialUse »; cela permet d'interdire l'utilisation à des fins commerciales. Encore une fois, il est possible de définir ses propres objets.

Dans le cas de la licence « Attribution-ShareAlike 2.0 », nous pouvons la décrire comme suit :

Sujet	Verbe	Objet
http://creativecommons.org/ licenses/by-sa/2.0/	http://www.w3.org/1999/ 02/22-rdf-syntax-ns#type	http://web.resource.org/ cc/License
http://creativecommons.org/ licenses/by-sa/2.0/	http://web.resource.org/ cc/permits	http://web.resource.org/ cc/Reproduction
http://creativecommons.org/ licenses/by-sa/2.0/	http://web.resource.org/ cc/permits	http://web.resource.org/ cc/Distribution
http://creativecommons.org/ licenses/by-sa/2.0/	http://web.resource.org/ cc/requires	http://web.resource.org/ cc/Notice
http://creativecommons.org/ licenses/by-sa/2.0/	http://web.resource.org/ cc/requires	http://web.resource.org/ cc/Attribution
http://creativecommons.org/ licenses/by-sa/2.0/	http://web.resource.org/ cc/permits	http://web.resource.org/ cc/DerivativeWorks
http://creativecommons.org/ licenses/by-sa/2.0/	http://web.resource.org/ cc/requires	http://web.resource.org/ cc/ShareAlike

Nous pouvons aussi utiliser le XML suivant :

<?xml version="1.0" encoding="ISO-8859-1"?>
<rdf:RDF xmlns="http://web.resource.org/cc/"
    xmlns:dc="http://purl.org/dc/elements/1.1/"
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<License rdf:about="http://creativecommons.org/licenses/by-sa/2.0/">
   <permits rdf:resource="http://web.resource.org/cc/Reproduction" />
   <permits rdf:resource="http://web.resource.org/cc/Distribution" />
   <requires rdf:resource="http://web.resource.org/cc/Notice" />
   <requires rdf:resource="http://web.resource.org/cc/Attribution" />
   <permits rdf:resource="http://web.resource.org/cc/DerivativeWorks" />
   <requires rdf:resource="http://web.resource.org/cc/ShareAlike" />
</License>
</rdf:RDF>

En pratique, nous combinons souvent le tout (description du travail et description de la licence) pour obtenir le XML suivant :

<rdf:RDF xmlns="http://web.resource.org/cc/"
  xmlns:dc="http://purl.org/dc/elements/1.1/"
  xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
 <Work rdf:about="http://teluq.ca/rdfexemples.html">
  <dc:title>Le RDF par l'exemple</dc:title>
  <license rdf:resource="http://creativecommons.org/licenses/by-sa/2.0/" /> 
</Work>
<License rdf:about="http://creativecommons.org/licenses/by-sa/2.0/">
   <permits rdf:resource="http://web.resource.org/cc/Reproduction" />
   <permits rdf:resource="http://web.resource.org/cc/Distribution" />
   <requires rdf:resource="http://web.resource.org/cc/Notice" />
   <requires rdf:resource="http://web.resource.org/cc/Attribution" />
   <permits rdf:resource="http://web.resource.org/cc/DerivativeWorks" />
   <requires rdf:resource="http://web.resource.org/cc/ShareAlike" />
</License>
</rdf:RDF>

Voilà! De cette manière, une machine pourra automatiquement déterminer quels droits l'utilisateur a sur une œuvre. Un logiciel pourrait automatiquement avertir l'utilisateur de ses obligations si jamais il tentait d'enregistrer sur son disque une copie de l'œuvre. Dans le cas d'une entreprise qui utilise beaucoup de contenu multimédia, l'utilisation de cette norme pourrait être très utile pour détecter automatiquement les violations des droits d'auteur.

Un exemple : FOAF

Les personnes sont souvent ce qu'il y a de plus important dans une organisation; il n'est donc pas étonnant qu'on veuille utiliser le RDF pour les décrire. Pour ce faire, on utilise souvent la norme FOAF pour « Friend-Of-A-Friend », ou un ami d'un ami, en français, (préfixe http://xmlns.com/foaf/0.1/) qui définit la classe « Person » (personne, en anglais).

Le projet FOAF a été lancé de façon informelle par Daniel Brickley en 1998. À l'époque, il avait mis un texte RDF ressemblant à ceci sur sa page personnelle : (Attention.- Il ne s'agit pas de RDF/XML valable.)

<RDF:RDF  
  xmlns="vocabdemo.rdf">
  xmlns:rdf="http://www.w3.org/TR/WD-rdf-syntax#">
  <Person ID="dan">
    <name> Dan Brickley </name>
    <Email> daniel.brickley@bristol.ac.uk </Email>
    <telephone rdf:resource = "phone:44-1-+44(0)117-9287493" />
    <pager rdf:resource = "phone:44-1-+44(0)2523-1781115" />
    <homePage 
    rdf:resource= "http://purl.org/net/danbri/" />
    <homePage 
    rdf:resource= "http://www.ilrt.bris.ac.uk/about/staff/dan.html"/>
  </Person>
</RDF:RDF>

La norme FOAF est très riche; mais à la base, on trouve les verbes suivants :

http://xmlns.com/foaf/0.1/name: Verbe pointant vers le nom de la personne (John Smith)
http://xmlns.com/foaf/0.1/nick: Verbe pointant vers le surnom informel de la personne (joblo).
http://xmlns.com/foaf/0.1/title: Verbe pointant vers le titre de la personne (docteur, monsieur, madame).
http://xmlns.com/foaf/0.1/homepage: Verbe pointant vers la page personnelle de la personne.
http://xmlns.com/foaf/0.1/mbox: Verbe pointant vers l'adresse électronique de la personne.
http://xmlns.com/foaf/0.1/img: Verbe pointant vers une image de la personne, la représentant spécifiquement.
http://xmlns.com/foaf/0.1/depiction: Verbe pointant vers une image représentant la personne. Contrairement à « img », l'image peut être une photo de groupe.
http://xmlns.com/foaf/0.1/family_name: Verbe pointant vers le nom de famille de la personne (Smith).
http://xmlns.com/foaf/0.1/givenname: Verbe pointant vers le prénom de la personne (John).

En XML, une description de l'auteur de ce document pourrait se présenter comme suit :

<?xml version="1.0" encoding="ISO-8859-1"?>
<rdf:RDF 
  xmlns:foaf="http://xmlns.com/foaf/0.1/"
  xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
 <foaf:Person>
   <foaf:givenname>Daniel</foaf:givenname>
   <foaf:family_name>Lemire</foaf:family_name>
   <foaf:homepage rdf:resource="http://lemire.me/fr/" />
   <foaf:mbox>lemire@uqam.ca</foaf:mbox>
   <foaf:img 
   rdf:resource="http://lemire.me/fr/images/GIF/zel2p.gif" />
 </foaf:Person>
</rdf:RDF>

Voici le graphe équivalent :

Notez que la balise « Person » n'a pas d'attribut « rdf:about ». Actuellement, il existe un débat sur cette question : Peut-on attribuer un URI unique à chaque individu et si oui, comment le choisir? C'est un cas où l'URI du sujet est « implicite » : cela signifie que dans les triplets sujet/verbe/objet, le sujet a un URI « fictif », qui n'est valable que dans le cadre du document que l'on traite. Autrement dit, le programme qui traite le document doit allouer dynamiquement un URI au sujet pour la durée du traitement. Rappelons-nous, en effet, que la norme RDF permet d'omettre le sujet, mais que si le sujet est spécifié, il doit être un URI.

Nous pouvons imaginer que la norme FOAF sera éventuellement utilisée pour représenter les réseaux sociaux, les organisations, et ainsi de suite. Une fois l'information sociale représentée de façon formelle, nous pouvons croire qu'il sera possible de poser des questions à un ordinateur de l'ordre suivant : Est-ce que je connais quelqu'un qui connaît quelqu'un travaillant chez IBM?

Un exemple : RSS/RDF

La version 1.0 de la norme RSS est un exemple de RDF. Cette norme dont l'acronyme n'a pas de définition établie, sert à représenter des fils de nouvelles. Elle a été imaginée par la compagnie Netscape et servait alors à la production du portail Netscape (1999). Elle est devenue très populaire et on trouve maintenant des milliers de fils de nouvelles en format RSS dans le monde. Par exemple, sur http://www.yulblog.org/, il y a des centaines de blogues écrits par des Montréalais et la plupart ont un fil de nouvelles en format RSS.

Une nouvelle, appelée « item » en RSS, prend la forme suivante :

<?xml version="1.0" encoding="ISO-8859-1"?>
<rdf:RDF 
  xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
  xmlns="http://purl.org/rss/1.0/">
  <item rdf:about="http://www.nouvelles.com/nouvelles1">
    <title>La bourse fait faillite</title>
    <link>http://www.nouvelles.com/nouvelles1.html</link>
    <description>
     Aujourd'hui, on a appris que la bourse a fait faillite.
    </description>
  </item>
</rdf:RDF>

Nous constatons qu'il y a une classe (item) et trois verbes (title, link, description) qui représentent respectivement le titre, l'URL et le contenu de la nouvelle.

Un document RSS est une liste d'items. Voici un document RSS :

<?xml version="1.0" encoding="ISO-8859-1"?>
<rdf:RDF 
  xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
  xmlns="http://purl.org/rss/1.0/">
  <channel rdf:about="http://www.nouvelles.com/nouvelles.rss">
    <title>Un site de nouvelles</title>
    <link>http://www.nouvelles.com/</link>
    <description>
      Nouvelles.com est un superbe site de nouvelles
    </description>   
    <!-- Ensuite, on place une séquence de nouvelles,
    les unes après les autres-->
    <items>
       <rdf:Seq>
         <!-- chaque nouvelle a un URI -->
         <rdf:li resource="http://www.nouvelles.com/nouvelles1" />
         <rdf:li resource="http://www.nouvelles.com/nouvelles2" />
      </rdf:Seq>
    </items>
  </channel>
</rdf:RDF>

Nous constatons une classe « channel » (canal, en anglais) qui contient un titre, un URL (link) et une description. Il y a aussi une liste de nouvelles (item). Généralement, nous combinons le tout dans un seul fichier, comme ceci :

<?xml version="1.0" encoding="ISO-8859-1"?>

<rdf:RDF 
  xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
  xmlns="http://purl.org/rss/1.0/">
  <channel rdf:about="http://www.nouvelles.com/nouvelles.rss">
    <title>Un site de nouvelles</title>
    <link>http://www.nouvelles.com/</link>
    <description>
      Nouvelles.com est un superbe site de nouvelles
    </description>   
    <!-- Ensuite, on place une séquence de nouvelles,
    les unes après les autres-->
    <items>
      <rdf:Seq>
        <!-- chaque nouvelle a un URI -->
        <rdf:li resource="http://www.nouvelles.com/nouvelles1" />
        <rdf:li resource="http://www.nouvelles.com/nouvelles2" />
     </rdf:Seq>
    </items>
  </channel>
  <item rdf:about="http://www.nouvelles.com/nouvelles1">
    <title>La bourse fait faillite</title>
    <link>http://www.nouvelles.com/nouvelles1.html</link>
    <description>
     Aujourd'hui, on a appris que la bourse a fait faillite.
    </description>
  </item>
  <item rdf:about="http://www.nouvelles.com/nouvelles2">
    <title>Rien ne va plus à l'école</title>
    <link>http://www.nouvelles.com/nouvelles2.html</link>
    <description>
     Un étudiant se serait rendu coupable d'apprentissage.
    </description>
  </item>
</rdf:RDF>

Les applications du RSS sont multiples. Supposons que votre organisation collabore avec plusieurs autres organisations et que vous vouliez rendre disponibles, sur une seule page web, toutes les nouvelles de toutes les organisations dont vous faites partie. Si chaque organisation rend disponible sur le web un document RSS toujours mis à jour, vous pouvez facilement récupérer les nouvelles de chacun et les afficher à un seul endroit. Au lieu de solliciter tous les membres par courriel, les fils de nouvelles RSS permettent à une machine de faire un tri et de personnaliser le contenu.

La norme RSS est en voie d'être remplacée par la norme Atom. Un des avantages du nouveau format Atom est que chaque nouvelle doit avoir un identifiant unique ce qui permet d'éviter les doublons. Cependant, la norme RSS risque d'être toujours utile pendant bien des années. Atom n'est pas en RDF/XML. En voici un exemple :

<?xml version="1.0" encoding="utf-8"?>
<feed xmlns="http://www.w3.org/2005/Atom">

 <title>Un site de nouvelles</title>
 <subtitle>Nouvelles.com est un superbe site de nouvelles</subtitle>
 <link href="http://www.nouvelles.com/"/>
 <updated>2003-12-13T18:30:02Z</updated>
 <author>
   <name>John Doe</name>
   <email>johndoe@example.com</email>
 </author>
 <id>urn:uuid:60a76c80-d399-11d9-b91C-0003939e0af6</id>

 <entry>
   <title>La bourse fait faillite</title>
   <link href="http://www.nouvelles.com/nouvelles1.html"/>
   <id>urn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a</id>
   <updated>2003-12-13T18:30:02Z</updated>
   <summary>Aujourd'hui, on a appris que la bourse a fait faillite.
   </summary>
 </entry>

</feed>

Conclusion

Nous avons étudié quatre applications importantes du RDF sur le web. Le nombre d'applications est toutefois beaucoup plus important. Par exemple, Facebook fait la promotion de la norme Open Graph.

Il faut garder à l'esprit que le RDF n'est pas le XML et que le XML ne sert qu'à représenter le RDF (et encore, ce n'est pas toujours possible).